
package ajedrez;

import java.util.ArrayList;
import java.util.List;
import javax.swing.tree.DefaultMutableTreeNode;

public class Generador
{
    
    public static final int MOV_RIGHT = 1;
    public static final int MOV_RIGHT_UP = -15;
    public static final int MOV_UP = -16;
    public static final int MOV_LEFT_UP = -17;
    public static final int MOV_LEFT = -1;
    public static final int MOV_LEFT_DOWN = 15;
    public static final int MOV_DOWN = 16;
    public static final int MOV_RIGHT_DOWN = 17;
    public static final int MOV_HORSE_RIGHT_UP1 = -14;
    public static final int MOV_HORSE_RIGHT_UP2 = -31;
    public static final int MOV_HORSE_LEFT_UP1 = -33;
    public static final int MOV_HORSE_LEFT_UP2 = -18;
    public static final int MOV_HORSE_LEFT_DOWN1 = 14;
    public static final int MOV_HORSE_LEFT_DOWN2 = 31;
    public static final int MOV_HORSE_RIGHT_DOWN1 = 33;
    public static final int MOV_HORSE_RIGHT_DOWN2 = 18;

    public boolean imprimir = true;


    public Generador()
    {}


    public DefaultMutableTreeNode GenerarMovimientos (Tablero pConfigTablero, int piJugador, int pProfundidad)
    {
        if(pProfundidad == 3)
            return new DefaultMutableTreeNode(new Nodo(pConfigTablero));
        else
        {
            List <Tablero> sucesores = new ArrayList();
            sucesores = this.getJugadas(pConfigTablero, piJugador);

            DefaultMutableTreeNode NodoPadre = null;
            NodoPadre = new DefaultMutableTreeNode(new Nodo(pConfigTablero));

            for(Tablero sucesor: sucesores) // Para cada sucesor.
            {
                DefaultMutableTreeNode NodoHijo = GenerarMovimientos(sucesor, getJugadorContrario(piJugador), pProfundidad+1);
                NodoPadre.add(NodoHijo);
                //Tablero.ImprimirMovimiento(pConfigTablero.Juego,sucesor.Juego);
            }
            return NodoPadre;
        }
    }

    /*
    public DefaultMutableTreeNode GenerarMovimientos (Tablero pConfigTotito, int piJugador, int pProfundidad)
    {

        if(Suficiente(pConfigTotito.Juego) || pProfundidad == 3)
            return new DefaultMutableTreeNode(new Nodo(pConfigTotito));
        else
        {
            List <Tablero> sucesores = new ArrayList();
            sucesores = this.getJugadas(pConfigTotito.Juego, piJugador);

            DefaultMutableTreeNode NodoPadre = null;
            NodoPadre = new DefaultMutableTreeNode(new Nodo(pConfigTotito));

            for(Tablero sucesor: sucesores) // Para cada sucesor.
            {
                DefaultMutableTreeNode NodoHijo = GenerarMovimientos(sucesor, getJugadorContrario(piJugador), pProfundidad+1);
                NodoPadre.add(NodoHijo);
            }
            return NodoPadre;
        }
    }
    */
    private List <Tablero> getJugadas(Tablero pConfigTablero, int pJugador)
    {
        List <Tablero> lstMovimientos = new ArrayList();

        List <Integer> lstPosPeones = new ArrayList();
        List <Integer> lstPosCaballos = new ArrayList();
        List <Integer> lstPosAlfiles = new ArrayList();
        List <Integer> lstPosTorres = new ArrayList();
        List <Integer> lstPosDama = new ArrayList();
        List <Integer> lstPosRey = new ArrayList();

        lstPosPeones = this.getListaPosicionesPieza(pConfigTablero, pJugador, Tablero.PEON);
        lstPosCaballos = this.getListaPosicionesPieza(pConfigTablero, pJugador, Tablero.CABALLO);
        lstPosAlfiles = this.getListaPosicionesPieza(pConfigTablero, pJugador, Tablero.ALFIL);
        lstPosTorres = this.getListaPosicionesPieza(pConfigTablero, pJugador, Tablero.TORRE);
        lstPosDama = this.getListaPosicionesPieza(pConfigTablero, pJugador, Tablero.DAMA);
        lstPosRey = this.getListaPosicionesPieza(pConfigTablero, pJugador, Tablero.REY);

        for(int i = 0; i < lstPosPeones.size(); i++)
        {
            int viPos = lstPosPeones.get(i);
            lstMovimientos.addAll(this.GenerarMovimientosPeon(pConfigTablero, pJugador, viPos));
        }
        for(int i = 0; i < lstPosCaballos.size(); i++)
        {
            int viPos = lstPosCaballos.get(i);
            lstMovimientos.addAll(this.GenerarMovimientosCaballo(pConfigTablero, pJugador, viPos));
        }
        for(int i = 0; i < lstPosAlfiles.size(); i++)
        {
            int viPos = lstPosAlfiles.get(i);
            lstMovimientos.addAll(this.GenerarMovimientosAlfil(pConfigTablero, pJugador, viPos));
        }
        for(int i = 0; i < lstPosTorres.size(); i++)
        {
            int viPos = lstPosTorres.get(i);
            lstMovimientos.addAll(this.GenerarMovimientosTorre(pConfigTablero, pJugador, viPos));
        }
        for(int i = 0; i < lstPosDama.size(); i++)
        {
            int viPos = lstPosDama.get(i);
            lstMovimientos.addAll(this.GenerarMovimientosDama(pConfigTablero, pJugador, viPos));
        }
        for(int i = 0; i < lstPosDama.size(); i++)
        {
            int viPos = lstPosDama.get(i);
            lstMovimientos.addAll(this.GenerarMovimientosDama(pConfigTablero, pJugador, viPos));
        }
        for(int i = 0; i < lstPosRey.size(); i++)
        {
            int viPos = lstPosRey.get(i);
            lstMovimientos.addAll(this.GenerarMovimientosRey(pConfigTablero, pJugador, viPos));
        }

        return lstMovimientos;
    }


    private List <Integer> getListaPosicionesPieza(Tablero pConfigTablero, int pJugador, int pPieza)
    {
        List <Integer> lstPosPeones = new ArrayList();
        
        for(int i = 0; i < Tablero.TamanioTablero; i++)
        {
            if((i & Tablero.PATRON) == 0)
            {
                if(pConfigTablero.Juego[i] == (pPieza * pJugador))
                    lstPosPeones.add(i);
            }

        }
        return lstPosPeones;
    }

    private List <Tablero> GenerarMovimientosDama(Tablero pConfigTablero, int pJugador, int posInicial)
    {
        int indice = posInicial;
        List <Tablero> lstJugadas = new ArrayList();
        int TipoMovimiento = 0;

        for(int i = 1; i <= 8; i++)
        {
            switch (i)
            {
                case 1:
                {
                    TipoMovimiento = MOV_RIGHT;
                    break;
                }
                case 2:
                {
                    TipoMovimiento = MOV_RIGHT_UP;
                    break;
                }
                case 3:
                {
                    TipoMovimiento = MOV_UP;
                    break;
                }
                case 4:
                {
                    TipoMovimiento = MOV_LEFT_UP;
                    break;
                }
                case 5:
                {
                    TipoMovimiento = MOV_LEFT;
                    break;
                }
                case 6:
                {
                    TipoMovimiento = MOV_LEFT_DOWN;
                    break;
                }
                case 7:
                {
                    TipoMovimiento = MOV_DOWN;
                    break;
                }
                case 8:
                {
                    TipoMovimiento = MOV_RIGHT_DOWN;
                    break;
                }
            }

            int viEntra = Tablero.PATRON & (indice + TipoMovimiento); // Si viEntada = 0 esta dentro del tablero si no esta fuera del tablero.

            int posActual = 0;
            int posNueva = -500; // Valor inicial.

            while(viEntra == 0 && !hayPiezaPropia(pConfigTablero.Juego, indice + TipoMovimiento, pJugador)) // Si Esta dentro del tablero y No hieza propia.
            {
                posActual = indice;
                posNueva = indice + TipoMovimiento;

                if(comePieza(pConfigTablero.Juego, posNueva, pJugador))
                    break;

                indice = posNueva;
                viEntra = Tablero.PATRON & (indice + TipoMovimiento);
            }

            if(posNueva != -500)
            {
                Tablero auxTablero = new Tablero();
                System.arraycopy(pConfigTablero.Juego, 0, auxTablero.Juego, 0, 128);
                auxTablero.Juego[posInicial] = Tablero.LIBRE;
                auxTablero.Juego[posActual] = Tablero.LIBRE;
                auxTablero.Juego[posNueva] = Tablero.DAMA * pJugador;
                auxTablero.pos = posNueva;
                auxTablero.pieza = Tablero.DAMA * pJugador;
                auxTablero.jugador = pJugador;

                lstJugadas.add(new Tablero(auxTablero));

                if(imprimir)
                {
                    Tablero.ImprimirMovimiento(pConfigTablero.Juego,auxTablero.Juego);
                    //Tablero.ImprimirTablero(auxTablero.Juego);
                }
            }

            indice = posInicial;
        }
        return lstJugadas;
    }

    private List <Tablero> GenerarMovimientosTorre(Tablero pConfigTablero, int pJugador, int posInicial)
    {
        int indice = posInicial;
        List <Tablero> lstJugadas = new ArrayList();
        int TipoMovimiento = 0;

        for(int i = 1; i <= 4; i++)
        {
            switch (i)
            {
                case 1:
                {
                    TipoMovimiento = MOV_RIGHT;
                    break;
                }
                case 2:
                {
                    TipoMovimiento = MOV_UP;
                    break;
                }
                case 3:
                {
                    TipoMovimiento = MOV_LEFT;
                    break;
                }
                case 4:
                {
                    TipoMovimiento = MOV_DOWN;
                    break;
                }
            }

            int viEntra = Tablero.PATRON & (indice + TipoMovimiento);

            int posActual = 0;
            int posNueva = -500; // Valor inicial.

            while(viEntra == 0 && !hayPiezaPropia(pConfigTablero.Juego, indice + TipoMovimiento, pJugador)) // Si Esta dentro del tablero y No hieza a la par.
            {
                posActual = indice;
                posNueva = indice + TipoMovimiento;

                if(comePieza(pConfigTablero.Juego, posNueva, pJugador))
                    break;

                indice = posNueva;
                viEntra = Tablero.PATRON & (indice + TipoMovimiento);
            }

            if(posNueva != -500)
            {
                Tablero auxTablero = new Tablero();
                System.arraycopy(pConfigTablero.Juego, 0, auxTablero.Juego, 0, 128);
                auxTablero.Juego[posInicial] = Tablero.LIBRE;
                auxTablero.Juego[posActual] = Tablero.LIBRE;
                auxTablero.Juego[posNueva] = Tablero.TORRE * pJugador;
                auxTablero.pos = posNueva;
                auxTablero.pieza = Tablero.TORRE * pJugador;
                auxTablero.jugador = pJugador;

                lstJugadas.add(new Tablero(auxTablero));

                if(imprimir)
                {
                    Tablero.ImprimirMovimiento(pConfigTablero.Juego,auxTablero.Juego);
                    //Tablero.ImprimirTablero(pConfigTablero.Juego);
                }
            }

            indice = posInicial;
        }
        return lstJugadas;
    }


    private List <Tablero> GenerarMovimientosAlfil(Tablero pConfigTablero, int pJugador, int posInicial)
    {
        int indice = posInicial;
        List <Tablero> lstJugadas = new ArrayList();
        int TipoMovimiento = 0;

        for(int i = 1; i <= 4; i++)
        {
            switch (i)
            {
                case 1:
                {
                    TipoMovimiento = Generador.MOV_RIGHT_UP;
                    break;
                }
                case 2:
                {
                    TipoMovimiento = Generador.MOV_LEFT_UP;
                    break;
                }
                case 3:
                {
                    TipoMovimiento = Generador.MOV_LEFT_DOWN;
                    break;
                }
                case 4:
                {
                    TipoMovimiento = Generador.MOV_RIGHT_DOWN;
                    break;
                }
            }

            int viEntra = Tablero.PATRON & (indice + TipoMovimiento);

            int posActual = 0;
            int posNueva = -500; // Valor inicial.

            while(viEntra == 0 && !hayPiezaPropia(pConfigTablero.Juego, indice + TipoMovimiento, pJugador)) // Si Esta dentro del tablero y No hieza a la par.
            {
                posActual = indice;
                posNueva = indice + TipoMovimiento;

                if(comePieza(pConfigTablero.Juego, posNueva, pJugador))
                    break;

                indice = posNueva;
                viEntra = Tablero.PATRON & (indice + TipoMovimiento);
            }

            if(posNueva != -500)
            {
                                Tablero auxTablero = new Tablero();
                System.arraycopy(pConfigTablero.Juego, 0, auxTablero.Juego, 0, 128);
                auxTablero.Juego[posInicial] = Tablero.LIBRE;
                auxTablero.Juego[posActual] = Tablero.LIBRE;
                auxTablero.Juego[posNueva] = Tablero.ALFIL * pJugador;
                auxTablero.pos = posNueva;
                auxTablero.pieza = Tablero.ALFIL * pJugador;
                auxTablero.jugador = pJugador;

                lstJugadas.add(new Tablero(auxTablero));

                if(imprimir)
                {
                    Tablero.ImprimirMovimiento(pConfigTablero.Juego,auxTablero.Juego);
                    //Tablero.ImprimirTablero(pConfigTablero.Juego);
                }
            }

            indice = posInicial;
        }
        return lstJugadas;
    }

    private List <Tablero> GenerarMovimientosRey(Tablero pConfigTablero, int pJugador, int posInicial)
    {
        int indice = posInicial;
        List <Tablero> lstJugadas = new ArrayList();
        int TipoMovimiento = 0;

        for(int i = 1; i <= 8; i++)
        {
            switch (i)
            {
                case 1:
                {
                    TipoMovimiento = MOV_RIGHT;
                    break;
                }
                case 2:
                {
                    TipoMovimiento = MOV_RIGHT_UP;
                    break;
                }
                case 3:
                {
                    TipoMovimiento = MOV_UP;
                    break;
                }
                case 4:
                {
                    TipoMovimiento = MOV_LEFT_UP;
                    break;
                }
                case 5:
                {
                    TipoMovimiento = MOV_LEFT;
                    break;
                }
                case 6:
                {
                    TipoMovimiento = MOV_LEFT_DOWN;
                    break;
                }
                case 7:
                {
                    TipoMovimiento = MOV_DOWN;
                    break;
                }
                case 8:
                {
                    TipoMovimiento = MOV_RIGHT_DOWN;
                    break;
                }
            }

            int viEntra = Tablero.PATRON & (indice + TipoMovimiento);
            if(viEntra == 0 && !hayPiezaPropia(pConfigTablero.Juego, indice + TipoMovimiento, pJugador)) // Si Esta dentro del tablero y No hieza a la par.
            {
                int posActual = indice;
                int posNueva = indice + TipoMovimiento;

                Tablero auxTablero = new Tablero();
                System.arraycopy(pConfigTablero.Juego, 0, auxTablero.Juego, 0, 128);
                auxTablero.Juego[posInicial] = Tablero.LIBRE;
                auxTablero.Juego[posActual] = Tablero.LIBRE;
                auxTablero.Juego[posNueva] = Tablero.REY * pJugador;
                auxTablero.pos = posNueva;
                auxTablero.pieza = Tablero.REY * pJugador;
                auxTablero.jugador = pJugador;

                lstJugadas.add(new Tablero(auxTablero));

                if(imprimir)
                {
                    //Tablero.ImprimirMovimiento(pConfigTablero.Juego,auxTablero.Juego);
                    Tablero.ImprimirTablero(pConfigTablero.Juego);
                }

                indice = posNueva;
                viEntra = Tablero.PATRON & (indice + TipoMovimiento);
            }
            indice = posInicial;
        }
        return lstJugadas;
    }

    private List <Tablero> GenerarMovimientosCaballo(Tablero pConfigTablero, int pJugador, int posInicial)
    {
        int indice = posInicial;
        List <Tablero> lstJugadas = new ArrayList();
        int TipoMovimiento = 0;

        for(int i = 1; i <= 8; i++)
        {
            switch (i)
            {
                case 1:
                {
                    TipoMovimiento = Generador.MOV_HORSE_RIGHT_UP1;
                    break;
                }
                case 2:
                {
                    TipoMovimiento = Generador.MOV_HORSE_RIGHT_UP2;
                    break;
                }
                case 3:
                {
                    TipoMovimiento = Generador.MOV_HORSE_LEFT_UP1;
                    break;
                }
                case 4:
                {
                    TipoMovimiento = Generador.MOV_HORSE_LEFT_UP2;
                    break;
                }
                case 5:
                {
                    TipoMovimiento = Generador.MOV_HORSE_LEFT_DOWN1;
                    break;
                }
                case 6:
                {
                    TipoMovimiento = Generador.MOV_HORSE_LEFT_DOWN2;
                    break;
                }
                case 7:
                {
                    TipoMovimiento = Generador.MOV_HORSE_RIGHT_DOWN1;
                    break;
                }
                case 8:
                {
                    TipoMovimiento = Generador.MOV_HORSE_RIGHT_DOWN2;
                    break;
                }
            }

            int viEntra = Tablero.PATRON & (indice + TipoMovimiento);
            if(viEntra == 0 && !hayPiezaPropia(pConfigTablero.Juego, indice + TipoMovimiento, pJugador)) // Si Esta dentro del tablero y No hieza a la par.
            {
                int posActual = indice;
                int posNueva = indice + TipoMovimiento;

                Tablero auxTablero = new Tablero();
                System.arraycopy(pConfigTablero.Juego, 0, auxTablero.Juego, 0, 128);
                auxTablero.Juego[posInicial] = Tablero.LIBRE;
                auxTablero.Juego[posActual] = Tablero.LIBRE;
                auxTablero.Juego[posNueva] = Tablero.CABALLO * pJugador;
                auxTablero.pos = posNueva;
                auxTablero.pieza = Tablero.CABALLO * pJugador;
                auxTablero.jugador = pJugador;

                lstJugadas.add(new Tablero(auxTablero));

                if(imprimir)
                {
                    //Tablero.ImprimirMovimiento(pConfigTablero.Juego,auxTablero.Juego);
                    Tablero.ImprimirTablero(pConfigTablero.Juego);
                }

                indice = posNueva;
                viEntra = Tablero.PATRON & (indice + TipoMovimiento);
            }
            indice = posInicial;
        }
        return lstJugadas;
    }

    private List <Tablero> GenerarMovimientosPeon(Tablero pConfigTablero, int pJugador, int posInicial)
    {
        boolean bloqueado = false;
        boolean movDerecha = true;
        boolean movIzquierda = true;

        int indice = posInicial;
        List <Tablero> lstJugadas = new ArrayList();
        int TipoMovimiento = 0;
        int orientacion = 1;

        if(pJugador == Tablero.BLANCAS)
            orientacion *= -1;

        int iInicio;
        int iFin = 4;

        if(indice + MOV_DOWN * 2 * orientacion == -13)
            iInicio = 0;

        if((esPrimeraFilaNegra(indice, pJugador) || esPrimeraFilaBlanca(indice, pJugador)) && !hayPieza(pConfigTablero.Juego, indice + MOV_DOWN * 2 * orientacion))
            iInicio = 1;
        else
            iInicio = 2;

        if(!comePieza(pConfigTablero.Juego, indice + MOV_RIGHT_DOWN * orientacion, pJugador))
            movDerecha = false;
        if(!comePieza(pConfigTablero.Juego, indice + MOV_LEFT_DOWN * orientacion, pJugador))
            movIzquierda = false;
        if(hayPieza(pConfigTablero.Juego, indice + MOV_DOWN * orientacion))
            bloqueado = true;


        for(int i = iInicio; i <= iFin; i++)
        {
            switch (i)
            {
                case 1:
                {
                    TipoMovimiento = MOV_DOWN * 2 * orientacion;
                    break;
                }
                case 2:
                {
                    TipoMovimiento = MOV_RIGHT_DOWN * orientacion;
                    break;
                }
                case 3:
                {
                    TipoMovimiento = MOV_DOWN * orientacion;
                    break;
                }
                case 4:
                {
                    TipoMovimiento = MOV_LEFT_DOWN * orientacion;
                    break;
                }
            }

            int viEntra = Tablero.PATRON & (indice + TipoMovimiento);

            if(i == 1 && bloqueado)
            {
                // Que no haga nada.
            }
            else if(i == 1 && viEntra == 0 && !hayPieza(pConfigTablero.Juego, indice + TipoMovimiento))
            {
                int posActual = indice;
                int posNueva = indice + TipoMovimiento;
                Tablero auxTablero = new Tablero();
                System.arraycopy(pConfigTablero.Juego, 0, auxTablero.Juego, 0, 128);
                auxTablero.Juego[posInicial] = Tablero.LIBRE;
                auxTablero.Juego[posActual] = Tablero.LIBRE;
                auxTablero.Juego[posNueva] = Tablero.PEON * pJugador;
                auxTablero.pos = posNueva;
                auxTablero.pieza = Tablero.PEON * pJugador;
                auxTablero.jugador = pJugador;

                lstJugadas.add(new Tablero(auxTablero));

                if(imprimir)
                {
                    //Tablero.ImprimirMovimiento(pConfigTablero.Juego,auxTablero.Juego);
                    Tablero.ImprimirTablero(pConfigTablero.Juego);
                }

                indice = posNueva;
                viEntra = Tablero.PATRON & (indice + TipoMovimiento);
            }
            else if(i == 2 && !movDerecha)
            {
                // Que no haga nada.
            }
            else if(i == 3 && bloqueado)
            {
                // Que no haga nada.
            }
            else if(i == 4 && !movIzquierda)
            {
                // Que no haga nada.
            }
            else if(viEntra == 0) // Si Esta dentro del tablero.
            {
                int posActual = indice;
                int posNueva = indice + TipoMovimiento;
                Tablero auxTablero = new Tablero();
                System.arraycopy(pConfigTablero.Juego, 0, auxTablero.Juego, 0, 128);
                auxTablero.Juego[posInicial] = Tablero.LIBRE;
                auxTablero.Juego[posActual] = Tablero.LIBRE;
                auxTablero.Juego[posNueva] = Tablero.PEON * pJugador;
                auxTablero.pos = posNueva;
                auxTablero.pieza = Tablero.PEON * pJugador;
                auxTablero.jugador = pJugador;

                lstJugadas.add(new Tablero(auxTablero));

                if(imprimir)
                {
                    //Tablero.ImprimirMovimiento(pConfigTablero.Juego,auxTablero.Juego);
                    Tablero.ImprimirTablero(pConfigTablero.Juego);
                }

                indice = posNueva;
                viEntra = Tablero.PATRON & (indice + TipoMovimiento);
            }
            indice = posInicial;
        }
        return lstJugadas;
    }
    
    public int[] getNuevoTablero(int[] pConfTablero, int posActual, int posNueva)
    {
        int[] vecRetornar = new int[128];

        vecRetornar = pConfTablero;
        vecRetornar[posActual] = Tablero.LIBRE;
        vecRetornar[posNueva] = Tablero.DAMA;
        
        return vecRetornar;
    }

    public static boolean esPrimeraFilaNegra(int posActual, int pJugador)
    {
        int[] fila = {16,17,18,19,20,21,22,23};

        if(pJugador == Tablero.NEGRAS)
        {
            for(int i = 0; i < fila.length; i++)
            {
                if(fila[i] == posActual)
                    return true;
            }
        }

        return false;
    }

    public static boolean esPrimeraFilaBlanca(int posActual, int pJugador)
    {
        int[] fila = {96,97,98,99,100,101,102,103};

        if(pJugador == Tablero.BLANCAS)
        {
            for(int i = 0; i < fila.length; i++)
            {
                if(fila[i] == posActual)
                    return true;
            }
        }
        return false;
    }

    public static boolean hayPieza(int[] pConfigTablero, int pPos)
    {
        try
        {
            if(pConfigTablero[pPos] != 0)
                return true;
            else
                return false;
        }
        catch(Exception e)
        {
            System.out.println(e.toString());
            return false;
        }
    }

    public static boolean hayPiezaPropia(int[] pConfigTablero, int pPos, int pJugador)
    {
        int pieza = pConfigTablero[pPos];
        if(pJugador == getJugador(pieza))
            return true;
        else
            return false;
    }

    public static boolean comePieza(int[] pConfigTablero, int pPos, int pJugador)
    {
        int pieza = pConfigTablero[pPos];
        int auxJugador = getJugador(pieza);
        if(auxJugador != 0 && pJugador != auxJugador)
            return true;
        else
            return false;
    }

    // Retorna de que jugador es la pieza.
    public static int getJugador(int pPieza)
    {
        if(pPieza < 0)
            return Tablero.NEGRAS;
        else if(pPieza > 0)
            return Tablero.BLANCAS;
        else
            return Tablero.LIBRE;
    }

    public static int getJugadorContrario(int piJugador)
    {
        if(piJugador == Tablero.NEGRAS)
            return Tablero.BLANCAS;
        else
            return Tablero.NEGRAS;
    }

    public static boolean Suficiente(int[] pConfigTotito)
    {
        return false;
    }

    /*
     * Para comprobar si la posicion esta dentro del tablero.
        int indice = pos;
        int valor = pos & 8;

        if(valor == 0)
            System.out.println("Dentro del tablero.");
        else
            System.out.println("Fuera del tablero.");
     */
}
